# Importamos la biblioteca TensorFlow para trabajar con redes neuronales y aprendizaje profundo.
import tensorflow as tf
# Importamos varias bibliotecas estándar y de terceros para diversas funcionalidades.
# Bibliotecas para manejo de archivos y tiempo.
import os
import time
import datetime
import random
import glob
# Bibliotecas numéricas y de análisis de datos.
import numpy as np
import pandas as pd
import scipy as sp
# Bibliotecas para visualización de datos.
import plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots
import plotly.io as pio
# Biblioteca para interactuar con bases de datos SQL.
from sqlalchemy import create_engine
# Biblioteca para cargar variables de entorno desde archivos .env.
from dotenv import load_dotenv
# Biblioteca para mostrar barras de progreso en bucles.
from tqdm import tqdm
2023-08-12 00:31:20.842694: I tensorflow/core/util/port.cc:110] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`. 2023-08-12 00:31:23.200249: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations. To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
La clase MDL es una implementación de Python que se utiliza para analizar datos de tráfico ferroviario y construir un Modelo de Aprendizaje Profundo (MDL) para predecir valores futuros. A continuación, se describen los principales métodos y funcionalidades de la clase:
__init__¶El constructor inicializa la clase MDL con los siguientes parámetros:
rail: Carril para el análisis de tráfico.date_min: Fecha mínima para el análisis.date_max: Fecha máxima para el análisis.feature_columns: Nombres de las columnas utilizadas como características.target_columns: Nombres de las columnas utilizadas como etiquetas.predict_columns: Nombres de las columnas utilizadas para las predicciones.calculate_df¶Este método realiza la manipulación y limpieza de los datos de tráfico. Realiza operaciones como:
self.df.calculate_data¶Realiza el preprocesamiento de los datos almacenados en self.df. Elimina filas nulas y atípicas basadas en la puntuación Z.
calculate_mdl¶Construye y entrena un Modelo de Aprendizaje Profundo utilizando una red neuronal secuencial. Utiliza la función de pérdida MAE y el optimizador Adam para el entrenamiento.
calculate_predict¶Genera predicciones utilizando el modelo entrenado y agrega los resultados al DataFrame principal.
calculate_info¶Realiza cálculos estadísticos y agrega información a un DataFrame de estadísticas. Calcula valores nulos, valores atípicos y varias métricas agregadas.
En resumen, la clase MDL se utiliza para analizar y preprocesar datos de tráfico , construir un Modelo de Aprendizaje Profundo y realizar análisis estadísticos sobre los resultados obtenidos. Cada método desempeña un papel crucial en el proceso de análisis de datos y construcción del modelo.
class MDL:
def __init__(self, *args, **kwargs):
"""
Constructor de la clase MDL.
Parámetros:
- rail: Carril para el que se desea analizar el tráfico.
- date_min: Fecha mínima para el análisis.
- date_max: Fecha máxima para el análisis.
- feature_columns: nombre de las columnas que el modelo toma como caracteristicas.
- target_columns: nombre de las columnas que el modelo toma como etquitas.
- predict_columns: nombre de las columnas que el modelo toma como etquitas para las predicciones
"""
self.rail = kwargs.get('rail')
self.date_min = kwargs.get('date_min')
self.date_max = kwargs.get('date_max')
self.feature_columns = kwargs.get('feature_columns')
self.target_columns = kwargs.get('target_columns')
self.predict_columns = kwargs.get('predict_columns')
# Llamar a los métodos para calcular el DataFrame y la información
self.calculate_df()
self.calculate_data()
self.calculate_mdl()
self.calculate_predict()
self.calculate_info()
def calculate_df(self, *args, **kwargs):
"""
Realiza un cálculo y manipulación de datos de tráfico a partir de una consulta SQL parametrizada.
Este método realiza las siguientes operaciones:
1. Ejecuta una consulta SQL parametrizada para obtener los datos de tráfico en un rango de fechas y carril especificado.
2. Carga las variables de entorno desde un archivo .env para la conexión a la base de datos.
3. Crea una conexión a la base de datos y lee los datos en un DataFrame.
4. Realiza manipulación y limpieza de los datos en el DataFrame.
5. Crea un DataFrame temporal con un rango de fechas y agrega columnas de tiempo para análisis posterior.
6. Combina los DataFrames por fecha y asigna el resultado a self.df.
Args:
*args: Argumentos posicionales (no se utilizan en este método).
**kwargs: Argumentos clave (no se utilizan en este método).
Returns:
None. El DataFrame resultante se asigna a self.df en la instancia de la clase.
"""
# Consulta SQL parametrizada para obtener los datos de tráfico en el rango de fechas y carril especificado
template_sql = """
SELECT Fecha AS date_hour, Intensidad AS value_intensity_real, Velocidad AS value_speed_real
FROM [MEDELLIN_GIP].[dbo].DatosTrafico_Hora
WHERE Fecha >= '{date_min}' AND Fecha <= '{date_max}' AND Carril = '{rail}';
"""
# Rellenar los valores en la consulta SQL
sql = template_sql.format(rail=self.rail, date_min=self.date_min, date_max=self.date_max)
# Cargar variables de entorno desde archivo .env para la conexión a la base de datos
load_dotenv()
user = os.getenv('user')
password = os.getenv('password')
localhost = os.getenv('localhost')
port = os.getenv('port')
database = os.getenv('database')
# Crear una conexión a la base de datos y leer los datos en un DataFrame
engine = create_engine(f'mssql+pymssql://{user}:{password}@{localhost}:{port}/{database}', echo=False)
connection = engine.connect()
df = pd.read_sql(sql=sql, con=connection)
# Manipulación y limpieza de los datos en el DataFrame
df['date_hour'] = pd.to_datetime(df["date_hour"])
df['date_hour'] = df['date_hour'].dt.round('1h')
df.drop_duplicates(subset=['date_hour'], inplace=True)
# Cerrar la conexion a la base de datos
connection.close()
# Crear un DataFrame temporal con un rango de fechas
df_tmp = pd.DataFrame(dict(date_hour=pd.date_range(start=self.date_min, end=self.date_max, freq='H')))
df_tmp['date_hour'] = pd.to_datetime(df_tmp['date_hour'])
df_tmp['rail'] = int(self.rail)
# Agregar columnas de tiempo para análisis temporal posterior
df_tmp['year'] = [i.year for i in df_tmp['date_hour']]
df_tmp['month'] = [i.month for i in df_tmp['date_hour']]
df_tmp['day'] = [i.day for i in df_tmp['date_hour']]
df_tmp['hour'] = [i.hour for i in df_tmp['date_hour']]
df_tmp['day_of_week'] = [i.dayofweek for i in df_tmp['date_hour']]
df_tmp['week_of_year'] = [i.week for i in df_tmp['date_hour']]
df_tmp['day_of_year'] = [i.dayofyear for i in df_tmp['date_hour']]
# Combinar DataFrames por fecha
df = pd.merge(df_tmp, df, on='date_hour', how='left')
self.df = df
def calculate_data(self, *args, **kwargs):
"""
Realiza el cálculo y preprocesamiento de los datos en el DataFrame.
Este método toma el DataFrame almacenado en el objeto y realiza las siguientes operaciones de preprocesamiento:
1. Elimina filas con valores nulos.
2. Elimina filas con valores atípicos basados en la puntuación Z.
3. Almacena el DataFrame preprocesado en el atributo 'df_data' del objeto.
Args:
*args: Argumentos posicionales opcionales.
**kwargs: Argumentos clave opcionales.
Returns:
None
"""
df=self.df.copy()
# Eliminar los datos null
df.dropna(inplace=True)
# Eliminar los datos atipicos
df = df[ (np.abs(sp.stats.zscore(df['value_intensity_real'])) <= 3.0) & (np.abs(sp.stats.zscore(df['value_speed_real'])) <= 3.0)]
# Almacenar el DataFrame con información limpia de nulos y datos atipicos para el entrenamiento del modelo
self.df_data = df
def calculate_mdl(self, *args, **kwargs):
"""
Calcula el Modelo de Aprendizaje Profundo (MDL) utilizando una red neuronal secuencial.
Este método construye una red neuronal secuencial con capas densas y lo entrena con los datos
de características y objetivos proporcionados en el DataFrame df_data. Utiliza la función de pérdida
de error absoluto medio (MAE) y el optimizador Adam para el entrenamiento.
Args:
args: Argumentos posicionales adicionales (no se utilizan en este método).
kwargs: Argumentos clave adicionales (no se utilizan en este método).
Returns:
None
Nota:
Este método modifica los siguientes atributos de la instancia:
- score: El valor de la métrica de error absoluto medio (MAE) del modelo en los datos de entrenamiento.
- model: El modelo de red neuronal entrenado.
"""
n_outputs=len(self.target_columns)
model = tf.keras.models.Sequential([
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(n_outputs, activation='linear')
])
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss=tf.keras.metrics.mae, metrics=[tf.keras.metrics.mae])
model.fit(self.df_data[self.feature_columns], self.df_data[self.target_columns], epochs=100, batch_size=25, validation_split=0.2, validation_steps=10, verbose=0)
self.score = model.evaluate(self.df_data[self.feature_columns], self.df_data[self.target_columns])
self.model=model
def calculate_predict(self, *args, **kwargs):
self.df_final=pd.concat([self.df.reset_index(drop=True), pd.DataFrame(data=self.model.predict(self.df[self.feature_columns]), columns=self.predict_columns)],axis=1)
def calculate_info(self, *args, **kwargs):
"""
Realiza cálculos estadísticos y agrega información a un DataFrame.
Este método calcula diversas estadísticas y agregaciones sobre los datos en un DataFrame
y almacena los resultados en otro DataFrame llamado 'df_info'. Las estadísticas calculadas
incluyen valores nulos, valores atípicos y agregaciones de datos en función de distintas
métricas y atributos.
Args:
*args: Argumentos posicionales (no se utilizan en este método).
**kwargs: Argumentos clave (no se utilizan en este método).
Returns:
None
"""
groups = [
"rail",
]
# Funciones personalizadas para cálculos estadísticos
# Funcion para calcular los datos nulos
def sum_isnan(x):
return np.isnan(x).sum()
# Funcion para calcular los porcentaje de datos nulos
def percent_isnan(x):
return np.isnan(x).sum() * 100 / np.size(x)
# Funcion para calcular los la cantidad de datos atipicos
def noutlier(x):
return np.array(np.where(np.abs(sp.stats.zscore(x[~np.isnan(x)])) > 3)).size
# Funcion para calcular los la cantidad porcentual de datos atipicos
def percent_noutlier(x):
return np.array(np.where(np.abs(sp.stats.zscore(x[~np.isnan(x)])) > 3)).size / np.size(x)
# Definición de agregaciones para el análisis estadístico
aggs = dict(
date_hour=['min', 'max'],
value_intensity_real=['sum', 'min', 'mean', 'max', 'count', 'size', sum_isnan, percent_isnan, noutlier, percent_noutlier],
value_speed_real=['sum', 'min', 'mean', 'max', 'count', 'size', sum_isnan, percent_isnan, noutlier, percent_noutlier],
value_intensity_predict=['sum', 'min', 'mean', 'max', 'count', 'size', sum_isnan, percent_isnan, noutlier, percent_noutlier],
value_speed_predict=['sum', 'min', 'mean', 'max', 'count', 'size', sum_isnan, percent_isnan, noutlier, percent_noutlier],
)
# Copiar DataFrame y realizar cálculos estadísticos
df = self.df_final.copy()
df = df.groupby(groups).agg(aggs).reset_index()
df.columns = df.columns.map("_".join).str.strip("_")
df['mae']=self.score[0]
# Almacenar el DataFrame con información estadística
self.df_info = df
El código realiza un análisis de datos de tráfico vehicular utilizando el módulo datetime para manejar fechas y horarios. A continuación se resumen los pasos principales:
Importar el módulo datetime: El código importa el módulo datetime para trabajar con fechas y horarios.
Asignar un código de carril: Se asigna un código de carril a la variable rail.
Definir las fechas mínima y máxima: Se definen las fechas mínima y máxima para el análisis, especificando el 1 de junio de 2022 y el 1 de junio de 2023 respectivamente.
Definir columnas de características: Se definen las columnas de características que se utilizarán en el modelo. Estas incluyen la semana del año, el día de la semana y la hora del día.
Definir columnas objetivo: Se definen las columnas objetivo que contienen los valores reales de intensidad y velocidad.
Definir columnas de predicción: Se definen las columnas de predicción que contendrán los valores predichos de intensidad y velocidad generados por el modelo.
Crear instancia de la clase MDL: Se crea una instancia de una clase MDL (posiblemente definida en otro lugar del código) con los parámetros especificados, incluyendo el código de carril, fechas, columnas de características, columnas objetivo y columnas de predicción.
# Asignar un código de carril a la variable 'rail'
rail = '0303134'
# Definir la fecha mínima y máxima para el análisis
date_min = datetime.datetime(2022, 6, 1, 0) # 1 de junio de 2022 a las 00:00
date_max = datetime.datetime(2023, 6, 1, 0) # 1 de junio de 2023 a las 00:00
# Definir las columnas de características que se utilizarán en el modelo
feature_columns = [
'week_of_year', # Semana del año
'day_of_week', # Día de la semana (0: lunes, 6: domingo)
'hour', # Hora del día (0-23)
]
# Definir las columnas objetivo (valores reales) que se utilizarán en el modelo
target_columns = [
'value_intensity_real', # Valor real de la intensidad
'value_speed_real', # Valor real de la velocidad
]
# Definir las columnas de predicción que se generarán a través del modelo
predict_columns = [
'value_intensity_predict', # Valor predicho de la intensidad
'value_speed_predict', # Valor predicho de la velocidad
]
# Crear una instancia de la clase MDL con los parámetros especificados
mdl = MDL(
**dict(
rail=rail,
date_min=date_min,
date_max=date_max,
feature_columns=feature_columns,
target_columns=target_columns,
predict_columns=predict_columns
)
)
263/263 [==============================] - 0s 1ms/step - loss: 13.9766 - mean_absolute_error: 13.9766 274/274 [==============================] - 1s 1ms/step
El resultado que estás viendo es el resultado de una iteración de entrenamiento de un modelo de TensorFlow.explicación de los valores que se muestran:
263/263: Esto indica que se han completado 263 pasos (iteraciones) de entrenamiento. La primera cifra (263) representa los pasos completados, y la segunda cifra (263) representa el total de pasos programados para esta ejecución.
- 0s 2ms/step: Esto indica el tiempo que tomó realizar cada paso de entrenamiento. En este caso, cada paso tomó aproximadamente 2 milisegundos.
loss: 13.6875: "loss" se refiere a la función de pérdida (loss function) que se utiliza para medir la discrepancia entre las predicciones del modelo y los valores reales del conjunto de datos. En este caso, el valor de la pérdida es 13.6875. Una pérdida más baja indica un mejor ajuste del modelo a los datos de entrenamiento.
mean_absolute_error: 12.3: El "mean_absolute_error" (error absoluto medio) es una métrica que mide la diferencia promedio entre las predicciones del modelo y los valores reales en términos absolutos. En este caso, el valor del error absoluto medio es 12.3. Cuanto menor sea este valor, mejor será el ajuste del modelo a los datos de entrenamiento.
En resumen, los valores que estás viendo indican que en esta iteración de entrenamiento, el modelo logró un error absoluto medio de alrededor de 12.3 en el conjunto de datos de entrenamiento. Ten en cuenta que estos valores pueden variar dependiendo de factores como la arquitectura del modelo, los datos de entrenamiento y los hiperparámetros utilizados en el proceso de entrenamiento.
date_hour: La fecha y hora en que se registraron los datos.rail: El número o identificador del tramo de carril.year: El año en que se registraron los datos.month: El mes en que se registraron los datos.day: El día del mes en que se registraron los datos.hour: La hora del día en que se registraron los datos.day_of_week: El día de la semana en que se registraron los datos (0 es domingo, 6 es sábado).week_of_year: El número de la semana en el año.day_of_year: El número del día en el año.value_intensity_real: La intensidad de tráfico real registrada en ese momento.value_speed_real: La velocidad real de tráfico registrada en ese momento.value_intensity_predict: La intensidad de tráfico pronosticada en ese momento.value_speed_predict: La velocidad de tráfico pronosticada en ese momento.df=mdl.df_final.copy()
df
| date_hour | rail | year | month | day | hour | day_of_week | week_of_year | day_of_year | value_intensity_real | value_speed_real | value_intensity_predict | value_speed_predict | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 2022-06-01 00:00:00 | 303134 | 2022 | 6 | 1 | 0 | 2 | 22 | 152 | 28.0 | 7.0 | 29.897038 | 7.664293 |
| 1 | 2022-06-01 01:00:00 | 303134 | 2022 | 6 | 1 | 1 | 2 | 22 | 152 | 17.0 | 6.0 | 16.450335 | 4.530858 |
| 2 | 2022-06-01 02:00:00 | 303134 | 2022 | 6 | 1 | 2 | 2 | 22 | 152 | 12.0 | 3.0 | 11.440790 | 2.903398 |
| 3 | 2022-06-01 03:00:00 | 303134 | 2022 | 6 | 1 | 3 | 2 | 22 | 152 | 15.0 | 5.0 | 12.876755 | 2.924136 |
| 4 | 2022-06-01 04:00:00 | 303134 | 2022 | 6 | 1 | 4 | 2 | 22 | 152 | 22.0 | 5.0 | 23.556971 | 6.685097 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| 8756 | 2023-05-31 20:00:00 | 303134 | 2023 | 5 | 31 | 20 | 2 | 22 | 151 | 248.0 | 20.0 | 177.403061 | 17.027924 |
| 8757 | 2023-05-31 21:00:00 | 303134 | 2023 | 5 | 31 | 21 | 2 | 22 | 151 | 212.0 | 18.0 | 134.948257 | 16.197107 |
| 8758 | 2023-05-31 22:00:00 | 303134 | 2023 | 5 | 31 | 22 | 2 | 22 | 151 | 192.0 | 18.0 | 79.100922 | 13.662395 |
| 8759 | 2023-05-31 23:00:00 | 303134 | 2023 | 5 | 31 | 23 | 2 | 22 | 151 | 132.0 | 18.0 | 48.094742 | 11.962787 |
| 8760 | 2023-06-01 00:00:00 | 303134 | 2023 | 6 | 1 | 0 | 3 | 22 | 152 | NaN | NaN | 29.715658 | 7.216057 |
8761 rows × 13 columns
Datos temporales:
date_hour_min: Fecha y hora mínimas de la serie de datos.date_hour_max: Fecha y hora máximas de la serie de datos.Intensidad real:
value_intensity_real_sum: Suma total de la intensidad real.value_intensity_real_min: Valor mínimo de la intensidad real.value_intensity_real_mean: Valor promedio (media) de la intensidad real.value_intensity_real_max: Valor máximo de la intensidad real.value_intensity_real_count: Número total de valores en la serie.value_intensity_real_size: Tamaño total de la serie.value_intensity_real_sum_isnan: Número de valores ausentes (NaN) en la serie.value_intensity_real_percent_isnan: Porcentaje de valores ausentes en la serie.value_intensity_real_noutlier: Número de valores atípicos en la serie.value_intensity_real_percent_noutlier: Porcentaje de valores atípicos.Velocidad real:
value_speed_real_sum: Suma total de la velocidad real.value_speed_real_min: Valor mínimo de la velocidad real.value_speed_real_mean: Valor promedio (media) de la velocidad real.value_speed_real_max: Valor máximo de la velocidad real.value_speed_real_count: Número total de valores en la serie.value_speed_real_size: Tamaño total de la serie.value_speed_real_sum_isnan: Número de valores ausentes (NaN) en la serie.value_speed_real_percent_isnan: Porcentaje de valores ausentes.value_speed_real_noutlier: Número de valores atípicos en la serie.value_speed_real_percent_noutlier: Porcentaje de valores atípicos.Intensidad predición:
value_intensity_predict_sum: Suma total de la intensidad predición.value_intensity_predict_min: Valor mínimo de la intensidad predición.value_intensity_predict_mean: Valor promedio (media) de la intensidad predición.value_intensity_predict_max: Valor máximo de la intensidad predición.value_intensity_predict_count: Número total de valores en la serie.value_intensity_predict_size: Tamaño total de la serie.value_intensity_predict_sum_isnan: Número de valores ausentes (NaN) en la serie.value_intensity_predict_percent_isnan: Porcentaje de valores ausentes en la serie.value_intensity_predict_noutlier: Número de valores atípicos en la serie.value_intensity_predict_percent_noutlier: Porcentaje de valores atípicos.Velocidad predición:
value_speed_predict_sum: Suma total de la velocidad predición.value_speed_predict_min: Valor mínimo de la velocidad predición.value_speed_predict_mean: Valor promedio (media) de la velocidad predición.value_speed_predict_max: Valor máximo de la velocidad predición.value_speed_predict_count: Número total de valores en la serie.value_speed_predict_size: Tamaño total de la serie.value_speed_predict_sum_isnan: Número de valores ausentes (NaN) en la serie.value_speed_predict_percent_isnan: Porcentaje de valores ausentes.value_speed_predict_noutlier: Número de valores atípicos en la serie.value_speed_predict_percent_noutlier: Porcentaje de valores atípicos.Error absoluto medio (MAE):
mae: Valor del error absoluto medio en las predicciones.df_tmp=mdl.df_info.copy()
df_tmp=df_tmp.T.reset_index().rename(columns={'index':'variable', 0:'value'})
df_tmp
| variable | value | |
|---|---|---|
| 0 | rail | 303134 |
| 1 | date_hour_min | 2022-06-01 00:00:00 |
| 2 | date_hour_max | 2023-06-01 00:00:00 |
| 3 | value_intensity_real_sum | 1363341.0 |
| 4 | value_intensity_real_min | 0.0 |
| 5 | value_intensity_real_mean | 159.194418 |
| 6 | value_intensity_real_max | 754.0 |
| 7 | value_intensity_real_count | 8564 |
| 8 | value_intensity_real_size | 8761 |
| 9 | value_intensity_real_sum_isnan | 197 |
| 10 | value_intensity_real_percent_isnan | 2.248602 |
| 11 | value_intensity_real_noutlier | 84 |
| 12 | value_intensity_real_percent_noutlier | 0.009588 |
| 13 | value_speed_real_sum | 148001.0 |
| 14 | value_speed_real_min | 0.0 |
| 15 | value_speed_real_mean | 17.281761 |
| 16 | value_speed_real_max | 125.0 |
| 17 | value_speed_real_count | 8564 |
| 18 | value_speed_real_size | 8761 |
| 19 | value_speed_real_sum_isnan | 197 |
| 20 | value_speed_real_percent_isnan | 2.248602 |
| 21 | value_speed_real_noutlier | 80 |
| 22 | value_speed_real_percent_noutlier | 0.009131 |
| 23 | value_intensity_predict_sum | 1267243.5 |
| 24 | value_intensity_predict_min | 9.475908 |
| 25 | value_intensity_predict_mean | 144.645981 |
| 26 | value_intensity_predict_max | 326.907135 |
| 27 | value_intensity_predict_count | 8761 |
| 28 | value_intensity_predict_size | 8761 |
| 29 | value_intensity_predict_sum_isnan | 0 |
| 30 | value_intensity_predict_percent_isnan | 0.0 |
| 31 | value_intensity_predict_noutlier | 0 |
| 32 | value_intensity_predict_percent_noutlier | 0.0 |
| 33 | value_speed_predict_sum | 135790.84375 |
| 34 | value_speed_predict_min | 2.641654 |
| 35 | value_speed_predict_mean | 15.499469 |
| 36 | value_speed_predict_max | 19.839184 |
| 37 | value_speed_predict_count | 8761 |
| 38 | value_speed_predict_size | 8761 |
| 39 | value_speed_predict_sum_isnan | 0 |
| 40 | value_speed_predict_percent_isnan | 0.0 |
| 41 | value_speed_predict_noutlier | 239 |
| 42 | value_speed_predict_percent_noutlier | 0.02728 |
| 43 | mae | 13.976562 |
** Conclusiones de la Gráfica de Dispersión (Intensidad vs Velocidad)
La variable velocidad muestra una alta dispersión en los datos, con la presencia de numerosos valores atípicos.
Por otro lado, la variable intensidad exhibe una variación mínima en la mayoría de los casos, indicando una relativa estabilidad en sus valores.
Se observa una relación entre la intensidad y la velocidad que se asemeja a una función subamortiguada, sugiriendo una correlación no lineal entre estas dos variables.
df=mdl.df_final.copy()
fig = px.scatter(df, x="value_intensity_real", y="value_speed_real", marginal_y="box", marginal_x="box")
fig.show()
** Conclusiones de la Gráfica de Dispersión
La gráfica de dispersión presenta una relación entre dos variables: intensidad pronosticada y velocidad pronosticada. A través del análisis de la gráfica, se pueden destacar las siguientes conclusiones:
El modelo ha generalizado de manera adecuada, ya que la gráfica revela una relación clara entre las variables. Esta relación se identifica como una función exponencial subamortiguada.
Se observa que los valores pronosticados se alinean con la tendencia de la gráfica, lo que sugiere que el modelo ha capturado eficazmente la naturaleza de la relación entre intensidad y velocidad pronosticada.
Es importante destacar que los valores pronosticados en términos de magnitud son en general menores que los valores reales. Esto puede atribuirse al hecho de que el conjunto de datos de entrenamiento ha excluido valores atípicos. Esta selección puede haber influido en la capacidad del modelo para predecir valores extremos.
En resumen, la gráfica de dispersión refleja una relación exponencial subamortiguada entre intensidad y velocidad pronosticada. El modelo ha logrado una buena generalización, pero es esencial tener en cuenta la influencia de los valores atípicos excluidos en las predicciones de magnitud.
df=mdl.df_final.copy()
fig = px.scatter(df, x="value_intensity_predict", y="value_speed_predict", marginal_y="box", marginal_x="box")
fig.show()
Conclusiones de la Gráfica de Histogramas
La gráfica muestra la sobreposición de histogramas de dos variables: intensidad real e intensidad pronosticada. Se observa claramente que ambas variables tienen la misma silueta, lo que sugiere una relación cercana entre ellas.
Además, se aprecia con claridad que los valores de la intensidad pronosticada son menores en magnitud en comparación con la intensidad real. Esta diferencia se debe al hecho de que el modelo fue entrenado excluyendo valores atípicos y extremos, lo que influyó en la magnitud de los pronósticos generados.
En resumen, la gráfica proporciona evidencia de la correspondencia entre las dos variables y destaca la influencia del entrenamiento del modelo en los valores pronosticados.
df=mdl.df_final.copy()
fig = px.histogram(df, x=["value_intensity_real",'value_intensity_predict'], marginal='box',histnorm='probability density')
fig.show()
Conclusiones de la Gráfica de Histogramas
La gráfica muestra la sobreposición de histogramas para dos variables: velocidad real y velocidad pronosticada. Se observa claramente que ambas variables tienen una silueta similar, lo que sugiere una relación entre ellas.
Además, es evidente que los valores de la velocidad pronosticada son menores en magnitud en comparación con la velocidad real. Esta discrepancia se debe a que el modelo de pronóstico fue entrenado sin valores atípicos ni extremos, lo que influye en la escala de los valores pronosticados.
En resumen, la gráfica de histogramas revela la similitud entre las velocidades reales y pronosticadas, así como la diferencia en magnitud debido al enfoque del modelo en los valores más comunes al ser entrenado.
df=mdl.df_final.copy()
fig = px.histogram(df, x=["value_speed_real",'value_speed_predict'], marginal='box',histnorm='probability density')
fig.show()
En el análisis de la gráfica de cajas y bigotes, se ha observado una correlación directa entre los pronósticos y los valores reales a lo largo de los días. Esta conclusión se sustenta en los siguientes puntos:
Coincidencia de Medias: Se ha notado que las medias de los pronósticos y los valores reales muestran una marcada coincidencia. Esta similitud entre las medias indica que el modelo ha logrado capturar el comportamiento general de los días y ha generado pronósticos cercanos a los valores reales.
Generalización del Comportamiento: El modelo ha logrado generalizar exitosamente el comportamiento de los días. Esto significa que no solo se ha ajustado a los datos de entrenamiento, sino que también puede aplicar el conocimiento aprendido a datos no vistos previamente. Esta capacidad de generalización es crucial para la precisión de los pronósticos.
En resumen, la gráfica de cajas y bigotes refleja una correlación positiva entre los pronósticos y los valores reales a lo largo de los días. La coincidencia de las medias y la habilidad del modelo para generalizar el comportamiento son indicativos de un buen rendimiento en la predicción de los valores. Esto sugiere que el modelo es confiable y preciso en su capacidad para prever los valores futuros basados en el histórico de datos.
df=mdl.df_final.copy()
df=pd.melt(df, id_vars='day_of_week', value_vars=['value_intensity_real','value_intensity_predict'])
variable=['value_intensity_real','value_intensity_predict']
df_tmp=df.query("variable in @variable")
fig=px.box(df_tmp, x='day_of_week', y='value', color='variable')
fig.show()
df=mdl.df_final.copy()
df=pd.melt(df, id_vars='day_of_week', value_vars=['value_speed_real','value_speed_predict'])
variable=['value_speed_real','value_speed_predict']
df_tmp=df.query("variable in @variable")
fig=px.box(df_tmp, x='day_of_week', y='value', color='variable')
fig.show()
En base a los resultados obtenidos, se puede concluir que el modelo desarrollado es aceptable y demuestra una capacidad satisfactoria para generalizar correctamente. Esto abre la puerta a su aplicación en diversos contextos.
Una de las principales utilidades del modelo es su capacidad para realizar predicciones en presencia de datos faltantes. La habilidad para llenar los vacíos en los conjuntos de datos y proporcionar estimaciones razonables es valiosa en escenarios donde la integridad de los datos es crucial para la toma de decisiones.
Además, el modelo muestra una habilidad prometedora para generar pronósticos. Esta capacidad de prever tendencias futuras basadas en los patrones identificados en los datos históricos puede ser de gran utilidad en la planificación estratégica y en la anticipación de posibles escenarios.
En resumen, el modelo no solo supera las expectativas en términos de generalización, sino que también ofrece aplicaciones prácticas en la imputación de datos faltantes y en la generación de pronósticos. Sin embargo, se recomienda un seguimiento continuo para evaluar y mejorar su rendimiento en diferentes situaciones y conjuntos de datos.